﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace V82.ОбщиеМодули
{
	public partial class НастройкаПравДоступа
	{

		public object СравнитьТаблицыНаборовЗаписей(/*ТаблицаЗначений1, ТаблицаЗначений2*/)
		{
			if(true/*ТипЗнч(ТаблицаЗначений1) <> Тип("ТаблицаЗначений") ИЛИ ТипЗнч(ТаблицаЗначений2) <> Тип("ТаблицаЗначений")*/)
			{
			}
			if(true/*ТаблицаЗначений1.Количество() <> ТаблицаЗначений2.Количество()*/)
			{
			}
			if(true/*ТаблицаЗначений1.Колонки.Количество() <> ТаблицаЗначений2.Колонки.Количество()*/)
			{
			}
			/*// Проверим поля
*/
			/*// сформируем строку индекса для оптимизации поиска по таблице значений
*/
			//СтрокаИндекса = "";
			/*// добавим индекс
*/
			//ТаблицаЗначений2.Индексы.Добавить(СтрокаИндекса);
			/*// Проверим записи
*/
			/*// сформируем строку индекса для оптимизации поиска по таблице значений
*/
			//СтрокаИндекса = "";
			/*// добавим индекс
*/
			//ТаблицаЗначений1.Индексы.Добавить(СтрокаИндекса);
			return null;
		}
		// СравнитьТаблицыЗначений()

		public object ПолучитьСтруктуруОтборовНабораЗаписей(/*ПраваДоступаПользователей*/)
		{
			//СтруктураОтбора = Новый Структура;
			return null;
		}
		/////////////////////////////////////////////////////////////////////////////////////
		// ОБЩИЕ ПРОЦЕДУРЫ И ФУНКЦИИ ОБСЛУЖИВАНИЯ МЕХАНИЗМА НАСТРОЙКИ ПРАВ ДОСТУПА
		// Возвращает вид объекта доступа
		//

		public object ПолучитьВидОбъектаДоступа(/*ОбъектДоступа*/)
		{
			if(true/*ТипЗнч(ОбъектДоступа) = Тип("СправочникСсылка.ФизическиеЛица")*/)
			{
			}
			return null;
		}
		// Возвращает тип объекта по виду объекта доступа
		//

		public object ПолучитьТипВидаОбъектаДоступа(/*ВидОбъектаДоступа*/)
		{
			if(true/*ВидОбъектаДоступа = Перечисления.ВидыОбъектовДоступа.ФизическиеЛица*/)
			{
			}
			return null;
		}
		// Проверка доступности права администрирования
		// это или полные права или право администрирования
		// Применяется для проверки прав на доступ к соотв. данным
		// Возвращаемое значение:
		//	булево - истина если есть доступ

		public object ДоступноПравоАдминистрирования(/**/)
		{
			return null;
		}
		// ДоступнаРольМенеджераПоНабору
		// Проверка необходимости наследуемые права только группами справочника

		public object ЗаполнениеДочернихТолькоГруппами(/*ВидОбъектаДоступа*/)
		{
			if(true/*ВидОбъектаДоступа = Перечисления.ВидыОбъектовДоступа.Номенклатура*/)
			{
			}
			return null;
		}
		/////////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ ОБСЛУЖИВАЮЩИЕ НАСЛЕДСТВЕННОСТЬ ПРАВ ДОСТУПА ПОЛЬЗОВАТЕЛЕЙ К ОБЪЕКТАМ

		public object ПолучитьМассивРодительскихЭлементов(/*Ссылка, МассивРодительскихЭлементов = Неопределено*/)
		{
			//ИмяРеквизитаРодителя = ПолучитьИмяРеквизитаРодителяОбъектаДоступа(Ссылка);
			if(true/*МассивРодительскихЭлементов = Неопределено*/)
			{
				//МассивРодительскихЭлементов = Новый Массив;
			}
			if(true/*Не ИмяРеквизитаРодителя = "Родитель" или Ссылка.Метаданные().Иерархический*/)
			{
				//ТекущийРодитель = Ссылка[ИмяРеквизитаРодителя];
				while(true/*ЗначениеЗаполнено(ТекущийРодитель)*/)
				{
					//МассивРодительскихЭлементов.Добавить(ТекущийРодитель);
					//ТекущийРодитель = ТекущийРодитель[ИмяРеквизитаРодителя];
				}
				//;;
			}
			return null;
		}

		public object ПолучитьМассивДочернихЭлементов(/*Родитель, МассивЭлементов = Неопределено, ТолькоГруппы = Ложь*/)
		{
			if(true/*МассивЭлементов = Неопределено*/)
			{
				//МассивЭлементов = Новый Массив;
			}
			//ИмяРеквизитаРодителя = ПолучитьИмяРеквизитаРодителяОбъектаДоступа(Родитель);
			//МетаданныеРодителя = Родитель.Метаданные();
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ
	|	_Таблица.Ссылка КАК Ссылка
	|ИЗ
	|	Справочник." + МетаданныеРодителя.Имя + " КАК _Таблица";*/
			if(true/*ЗначениеЗаполнено(Родитель)*/)
			{
				if(true/*ИмяРеквизитаРодителя = "Родитель"*/)
				{
					if(true/*Не МетаданныеРодителя.Иерархический или МетаданныеРодителя.ВидИерархии = Метаданные.СвойстваОбъектов.ВидИерархии.ИерархияГруппИЭлементов и Не Родитель.ЭтоГруппа*/)
					{
					}
					/*Запрос.Текст = Запрос.Текст + "
			|ГДЕ
			|	_Таблица.Ссылка В ИЕРАРХИИ(&Родитель)
			|	И _Таблица.Ссылка <> &Родитель";*/
				}
				//Запрос.УстановитьПараметр("Родитель", Родитель);
			}
			if(true/*ТолькоГруппы*/)
			{
				if(true/*ЗначениеЗаполнено(Родитель)*/)
				{
					/*Запрос.Текст = Запрос.Текст + "
			|	И _Таблица.Ссылка.ЭтоГруппа";*/
				}
			}
			//ДобавлятьРекурсивно = Не ИмяРеквизитаРодителя = "Родитель" и ЗначениеЗаполнено(Родитель);
			//Выборка = Запрос.Выполнить().Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//МассивЭлементов.Добавить(Выборка.Ссылка);
				if(true/*ДобавлятьРекурсивно*/)
				{
					//ПолучитьМассивДочернихЭлементов(Выборка.Ссылка, МассивЭлементов, ТолькоГруппы);
				}
			}
			return null;
		}
		// ()

		public void ДополнитьНаборПравДоступаУнаследованнымиЗаписями(/*ПраваДоступаПользователей, ОбъектДоступа, Родитель*/)
		{
			//ОбъектДоступаМетаданные = ОбъектДоступа.Метаданные();
			/*// Добавим записи, унаследованные от родителей
*/
			//Родители = Новый Массив;
			//ТекущийРодитель = Родитель;
			while(true/*ЗначениеЗаполнено(ТекущийРодитель)*/)
			{
				//Родители.Добавить(ТекущийРодитель);
				//ТекущийРодитель = ТекущийРодитель.Родитель;
			}
			/*;
	Родители.Добавить(ТекущийРодитель);*/
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ
	|	*
	|ИЗ
	|	РегистрСведений.НастройкиПравДоступаПользователей КАК ПраваДоступаПользователей
	|ГДЕ
	|	ПраваДоступаПользователей.ОбъектДоступа В(&Родители)
	|	И ПраваДоступаПользователей.ВидНаследованияПравДоступаИерархическихСправочников = &РаспространитьНаПодчиненных";*/
			if(true/*ПраваДоступаПользователей.Отбор.ОбластьДанных.Использование*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
		|	И ПраваДоступаПользователей.ОбластьДанных = &ОбластьДанных";*/
				//Запрос.УстановитьПараметр("ОбластьДанных", ПраваДоступаПользователей.Отбор.ОбластьДанных.Значение);
			}
			if(true/*ПраваДоступаПользователей.Отбор.Пользователь.Использование*/)
			{
				/*Запрос.Текст = Запрос.Текст + "
		|	И ПраваДоступаПользователей.Пользователь = &Пользователь";*/
				//Запрос.УстановитьПараметр("Пользователь", ПраваДоступаПользователей.Отбор.Пользователь.Значение);
			}
			//Запрос.УстановитьПараметр("Родители", Родители);
			//Запрос.УстановитьПараметр("РаспространитьНаПодчиненных", Перечисления.ВидыНаследованияПравДоступаИерархическихСправочников.РаспространитьНаПодчиненных);
			//Результат = Запрос.Выполнить();
			//Выборка = Результат.Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//Запись = ПраваДоступаПользователей.Добавить();
				//ЗаполнитьЗначенияСвойств(Запись, Выборка,,"ОбъектДоступа, ВидНаследованияПравДоступаИерархическихСправочников");
				//Запись.ОбъектДоступа = ОбъектДоступа;
				//Запись.ВидНаследованияПравДоступаИерархическихСправочников = Перечисления.ВидыНаследованияПравДоступаИерархическихСправочников.НаследуетсяОтРодителя;
			}
			//;;
		}
		// ()

		public object ПолучитьИмяРеквизитаРодителяОбъектаДоступа(/*Ссылка*/)
		{
			if(true/*ТипЗНЧ(Ссылка) = Тип("СправочникСсылка.Организации")*/)
			{
			}
			return null;
		}
		// ()

		public void ДополнитьНаборПравДоступаНаследуемымиЗаписями(/*НаборПрав*/)
		{
			//ИсходнаяТаблица = ПолучитьТаблицуПравДоступаБезУнаследуемыхЗаписей(НаборПрав);
			//СоответствиеМассивовДочернихЭлементов     = Новый Соответствие;
			//СоответствиеМассивовРодительскихЭлементов = Новый Соответствие;
		}
		// ()

		public void ДополнитьНаборПравДоступаГруппамиПользователей(/*НаборПрав*/)
		{
			//РезультатЗапросаВсеГруппы = ПолучитьРезультатЗапросаКоВсемГруппамПользователей();
			if(true/*РезультатЗапросаВсеГруппы.Пустой()*/)
			{
			}
			//ВыборкаВсеГруппы = РезультатЗапросаВсеГруппы.Выбрать();
			//ИсходноеКолвоЗаписейВНаборе = НаборПрав.Количество();
		}

		public object ПолучитьРезультатЗапросаКоВсемГруппамПользователей(/**/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = 
	"ВЫБРАТЬ
	|	ГруппыПользователей.Ссылка
	|ИЗ
	|	Справочник.ГруппыПользователей КАК ГруппыПользователей
	|ГДЕ
	|	ГруппыПользователей.Ссылка <> ЗНАЧЕНИЕ(Справочник.ГруппыПользователей.ВсеПользователи)";*/
			return null;
		}

		public object ПолучитьТаблицуПравДоступаБезУнаследуемыхЗаписей(/*ПраваДоступаПользователей*/)
		{
			//ТаблицаПравДоступа = РегистрыСведений.НастройкиПравДоступаПользователей.СоздатьНаборЗаписей().Выгрузить();
			return null;
		}

		public void ПередЗаписьюНовогоОбъектаСПравамиДоступаПользователей(/*ЭтотОбъект, Отказ, Родитель, СсылкаНового = Неопределено*/)
		{
			if(true/*ЭтотОбъект.ЭтоНовый()*/)
			{
				//СсылкаНового = ЭтотОбъект.ПолучитьСсылкуНового();
				if(true/*НЕ ЗначениеЗаполнено(СсылкаНового)*/)
				{
					//СсылкаНового = Справочники[ЭтотОбъект.Метаданные().Имя].ПолучитьСсылку();
				}
				//ПолныеПрава.ЗарегистрироватьПраваДоступаПользователяКОбъекту(СсылкаНового, Родитель, Отказ);
				if(true/*НЕ Отказ И НЕ ЗначениеЗаполнено(ЭтотОбъект.ПолучитьСсылкуНового())*/)
				{
					//ЭтотОбъект.УстановитьСсылкуНового(СсылкаНового);
				}
			}
		}

		public void ПрочитатьПраваДоступаКОбъекту(/*ПраваДоступаПользователей, Ссылка*/)
		{
			/*// Снимем все отборы
*/
			if(true/*ТипЗнч(Ссылка) = Тип("СправочникСсылка.Пользователи") ИЛИ ТипЗнч(Ссылка) = Тип("СправочникСсылка.ГруппыПользователей")*/)
			{
				//ПраваДоступаПользователей.Отбор.Пользователь.Значение = Ссылка;
				//ПраваДоступаПользователей.Отбор.Пользователь.Использование = Истина;
			}
			//ПраваДоступаПользователей.Прочитать();
		}

		public void ОбновитьПраваДоступаКИерархическимОбъектамПриНеобходимости(/*Ссылка, ПрошлыйИзмененныйРодительОбъектаДоступа, Отказ*/)
		{
			/*//В объекте не был изменен родитель. Обновлять права доступа нет необходимости
*/
			if(true/*ПрошлыйИзмененныйРодительОбъектаДоступа = Неопределено Или Отказ*/)
			{
			}
			//ОбновляемыеОбъекты = Новый Массив;
			//ОбновляемыеОбъекты.Добавить(Ссылка);
			//ПолучитьМассивРодительскихЭлементов(Ссылка, ОбновляемыеОбъекты);
			if(true/*ЗначениеЗаполнено(ПрошлыйИзмененныйРодительОбъектаДоступа)*/)
			{
				//ПолныеПрава.ОбновитьПраваДоступаКПрошлымРодителям(Ссылка, ПрошлыйИзмененныйРодительОбъектаДоступа, Отказ);
				if(true/*Отказ*/)
				{
				}
			}
			//ШапкаОшибки = "Права " + Ссылка + " не записан!";
			//ОбновляемыеОбъекты = ПолныеПрава.ПолучитьСписокОбновляемыхОбъектовПриПереносеВГруппу(Ссылка, ОбновляемыеОбъекты);
		}
		// ОбновитьПраваДоступаКИерархическимОбъектамПриНеобходимости

		public void ЗаписатьПраваДоступаПользователейКОбъекту(/*ПраваДоступаПользователей, Ссылка, Отказ, ПрошлыйИзмененныйРодительОбъектаДоступа = Неопределено*/)
		{
			if(true/*Отказ*/)
			{
			}
			//ОтборПоПользователю = ТипЗнч(Ссылка) = Тип("СправочникСсылка.Пользователи") ИЛИ ТипЗнч(Ссылка) = Тип("СправочникСсылка.ГруппыПользователей");
			if(true/*ОтборПоПользователю*/)
			{
				//ПраваДоступаПользователей.Отбор.Пользователь.Установить(Ссылка);
			}
			//ТаблицаПравДоступа = ПолучитьТаблицуПравДоступаБезУнаследуемыхЗаписей(ПраваДоступаПользователей);
			//СтруктураОтбора = ПолучитьСтруктуруОтборовНабораЗаписей(ПраваДоступаПользователей);
			//ПолныеПрава.ЗаписатьПраваДоступаПользователей(ТаблицаПравДоступа,СтруктураОтбора, Отказ, "Не записаны права доступа к объекту """+ Ссылка + """!");
			if(true/*НЕ Отказ*/)
			{
				//ПрочитатьПраваДоступаКОбъекту(ПраваДоступаПользователей, Ссылка);
			}
		}
		/////////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ И ФУНКЦИИ ОБСЛУЖИВАЮЩИЕ СОБЫТИЯ ЭЛЕМЕНТОВ УПРАВЛЕНИЯ ФОРМ

		public void РедактироватьПраваДоступа(/*Ссылка = Неопределено*/)
		{
			//ТипЗначенияВыбора = ТипЗнч(Ссылка);
			//НастройкаДляГруппПользователей = (Ссылка = Неопределено ИЛИ (ТипЗначенияВыбора = Тип("СправочникСсылка.ГруппыПользователей")));
			//ОбработкаНастройкаПравДоступа = Обработки.НастройкаПравДоступа;
			if(true/*НастройкаДляГруппПользователей*/)
			{
				/*// Настройка для групп пользователей выполняется в одной форме
*/
				//ФормаРедактирования = ОбработкаНастройкаПравДоступа.ПолучитьФорму(,, "НастройкаПравДоступа");
			}
			//ФормаРедактирования.НачальноеЗначениеВыбора = Ссылка;
			//ФормаРедактирования.Открыть();
		}

		public void СформироватьВариантОтчетаПоСистемеПрав(/*ИмяВариантаОтчета*/)
		{
			//ОтчетОбъект = Отчеты.ОтчетПоСистемеПрав.Создать();
			//ФормаОтчета = ОтчетОбъект.ПолучитьФорму();
			//ФормаОтчета.Открыть();
			//ФормаОтчета.СохраненнаяНастройка = Справочники.СохраненныеНастройки[ИмяВариантаОтчета];
			//ФормаОтчета.ПрименитьНастройку();
			if(true/*Не ФормаОтчета.РежимРедактированияНастройки*/)
			{
				//ТиповыеОтчеты.ОбновитьТаблицуДоступныхНастроекПользователю(ОтчетОбъект);
				//ТиповыеОтчеты.ОбновитьКнопкиВыбораНастроек(ФормаОтчета, ОтчетОбъект, ФормаОтчета.ПредставлениеНастройки,  ФормаОтчета.РежимРедактированияНастройки);
			}
			//ФормаОтчета.Модифицированность = Ложь;
			//ФормаОтчета.ОбновитьОтчет();
		}
		// СформироватьВариантТиповогоОтчета

		public object ПолучитьСписокВидовНаследованияПравДоступа(/*ОбъектДоступа*/)
		{
			//СписокПеречисления = Новый СписокЗначений;
			if(true/*НЕ ЗначениеЗаполнено(ОбъектДоступа) или ТипЗнч(ОбъектДоступа) = Тип("СправочникСсылка.Организации")*/)
			{
				//СписокПеречисления.Добавить(Перечисления.ВидыНаследованияПравДоступаИерархическихСправочников.РаспространитьНаПодчиненных);
				//СписокПеречисления.Добавить(Перечисления.ВидыНаследованияПравДоступаИерархическихСправочников.ТолькоДляТекущегоПрава);
			}
			return null;
		}
		/////////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ  - ОБРАБОТЧИКИ ПОДПИСОК НА СОБЫТИЯ МЕХАНИЗМА ДАТЫ ЗАПРЕТА РЕДАКТИРОВАНИЯ
		// Процедура выполняет проверку возможности записи документов
		// с учетом даты запрета изменения данных (даты запрета редактирования)
		//

		public void ПроверкаПериодаДокумента(/*ДокументОбъект, Отказ, РежимЗаписи*/)
		{
			//СоответствиеГраницЗапрета = ПараметрыСеанса.ГраницыЗапретаИзмененияДанных.Получить();
			/*// Для пользователя с полными правами проверок выполнять не нужно
*/
			if(true/*СоответствиеГраницЗапрета = Неопределено*/)
			{
			}
			//ПараметрыПроверкиДокумента = ПолучитьПараметрыПроверкиДокумента(ДокументОбъект);
			if(true/*Не ДокументОбъект.ЭтоНовый()*/)
			{
				//СтараяВерсияДокумента = ПолучитьВерсиюДокументаПередИзменением(ДокументОбъект, ПараметрыПроверкиДокумента);
				//ПроверитьВерсиюДокумента(СтараяВерсияДокумента, ПараметрыПроверкиДокумента, СоответствиеГраницЗапрета, Отказ);
			}
			if(true/*Не Отказ*/)
			{
				//ПроверитьВерсиюДокумента(ДокументОбъект, ПараметрыПроверкиДокумента, СоответствиеГраницЗапрета, Отказ, РежимЗаписи);
			}
		}
		// ПроверкаПериодаДокумента
		// Функция возвращает "эффективную" дату документа, которая будет сравниваться с установленной датой запрета

		public object ПолучитьДатуДляПроверкиДокумента(/*ДокументОбъект, ПараметрыПроверкиДокумента*/)
		{
			/*// Определение даты для "особых" случаев.
*/
			//ДатаДляПроверки = НастройкаПравДоступаПереопределяемый.ПолучитьДатуПроверкиПоТипуДокумента(ДокументОбъект, ПараметрыПроверкиДокумента);
			if(true/*ЗначениеЗаполнено(ДатаДляПроверки)*/)
			{
			}
			/*// Значение даты не определено. Рассчитывается для общему алгоритму.
*/
			if(true/*ПараметрыПроверкиДокумента.Свойство("ИмяПоляПериодаРегистрации")*/)
			{
			}
			return null;
		}
		// Процедура проверки версии документа на нарушение даты запрета
		//

		public void ПроверитьВерсиюДокумента(/*ДокументОбъект, ПараметрыПроверкиДокумента, СоответствиеГраницЗапрета, Отказ, РежимЗаписи = Неопределено*/)
		{
			if(true/*ПараметрыПроверкиДокумента.ПроверятьПроведениеДокумента*/)
			{
				//ДокументПроведен = ДокументОбъект.Проведен ИЛИ ?(РежимЗаписи = Неопределено, Ложь, РежимЗаписи = РежимЗаписиДокумента.Проведение);
				if(true/*НЕ ДокументПроведен*/)
				{
				}
			}
			/*// Не выполняется проверка дат запрета редактирования
*/
			if(true/*НЕ ПараметрыПроверкиДокумента.ПроверятьУправленческуюДатуЗапрета
		И НЕ ПараметрыПроверкиДокумента.ПроверятьРегламентированнуюДатуЗапрета*/)
			{
			}
			//ДатаДляПроверки = ПолучитьДатуДляПроверкиДокумента(ДокументОбъект, ПараметрыПроверкиДокумента);
			/*// Проверка даты запрета по организации
*/
			if(true/*ПараметрыПроверкиДокумента.ПроверятьРегламентированнуюДатуЗапрета*/)
			{
				//ГраницаПериода = СоответствиеГраницЗапрета[ДокументОбъект.Организация];
				/*// Если дата запрета по организации не определена, то используется основная дата запрета для пользователя
*/
				if(true/*НЕ ЗначениеЗаполнено(ГраницаПериода)*/)
				{
					//ГраницаПериода = СоответствиеГраницЗапрета[Справочники.Организации.ПустаяСсылка()];
				}
				/*// Если основная дата запрета для пользователя не определена, то используется общая дата запрета
*/
				if(true/*НЕ ЗначениеЗаполнено(ГраницаПериода)*/)
				{
					//ГраницаПериода = СоответствиеГраницЗапрета["ОбщаяДатаЗапретаРедактирования"];
				}
				if(true/*ЗначениеЗаполнено(ГраницаПериода)
			И ДатаДляПроверки <= КонецДня(ГраницаПериода)*/)
				{
					//Отказ = Истина;
				}
			}
			/*// Проверка основной даты запрета
*/
			if(true/*ПараметрыПроверкиДокумента.ПроверятьУправленческуюДатуЗапрета*/)
			{
				//ГраницаПериода = СоответствиеГраницЗапрета[Справочники.Организации.ПустаяСсылка()];
				/*// Если основная дата для пользователя не определена, то используется общая дата запрета
*/
				if(true/*НЕ ЗначениеЗаполнено(ГраницаПериода)*/)
				{
					//ГраницаПериода = СоответствиеГраницЗапрета["ОбщаяДатаЗапретаРедактирования"];
				}
				if(true/*ЗначениеЗаполнено(ГраницаПериода)*/)
				{
					if(true/*ДатаДляПроверки <= КонецДня(ГраницаПериода)*/)
					{
						//Отказ = Истина;
					}
				}
			}
		}
		// Функция возвращает из БД версию документа до его изменения
		//

		public object ПолучитьВерсиюДокументаПередИзменением(/*ДокументОбъект, ПараметрыПроверкиДокумента*/)
		{
			//Запрос = Новый Запрос;
			/*Запрос.Текст = "
	|ВЫБРАТЬ 
	|Дата" 
	+ ?(ПараметрыПроверкиДокумента.ЕстьОрганизация, "," + Символы.ПС + "Организация КАК Организация", "")
	+ ?(ПараметрыПроверкиДокумента.ЕстьУправленческийУчет, "," + Символы.ПС + "ОтражатьВУправленческомУчете КАК ОтражатьВУправленческомУчете", "")
	+ ?(ПараметрыПроверкиДокумента.ЕстьБухгалтерскийУчет, "," + Символы.ПС + "ОтражатьВБухгалтерскомУчете КАК ОтражатьВБухгалтерскомУчете", "")
	+ ?(ПараметрыПроверкиДокумента.Свойство("ИмяПоляПериодаРегистрации"), "," + Символы.ПС + ПараметрыПроверкиДокумента.ИмяПоляПериодаРегистрации + " КАК " + ПараметрыПроверкиДокумента.ИмяПоляПериодаРегистрации, "")
	+ ?(ПараметрыПроверкиДокумента.ПроверятьПроведениеДокумента, "," + Символы.ПС + "Проведен КАК Проведен", "");*/
			//ДополнитьТекстЗапросаПоТипуДокумета(Запрос.Текст, ПараметрыПроверкиДокумента);
			/*Запрос.Текст = Запрос.Текст + "
	|ИЗ Документ." + ПараметрыПроверкиДокумента.МетаданныеДокумента.Имя + "
	|ГДЕ Ссылка = &Ссылка";*/
			//Запрос.УстановитьПараметр("Ссылка", ДокументОбъект.Ссылка);
			//Выборка = Запрос.Выполнить().Выбрать();
			//Выборка.Следующий();
			return null;
		}
		// ПолучитьВерсиюДокументаПередИзменением()

		public void ДополнитьТекстЗапросаПоТипуДокумета(/*ТекстЗапроса, ПараметрыПроверкиДокумента*/)
		{
			if(true/*ПараметрыПроверкиДокумента.МетаданныеДокумента = Метаданные.Документы.ВводПроцентаДеятельностиЕНВД*/)
			{
				//ДополнитьТекстЗапросаВводПроцентаДеятельностиЕНВД(ТекстЗапроса);
			}
		}

		public void ДополнитьТекстЗапросаВводПроцентаДеятельностиЕНВД(/*ТекстЗапроса*/)
		{
			/*ТекстЗапроса = ТекстЗапроса + ",
	|ВводДанныхПоПериодам КАК ВводДанныхПоПериодам,
	|РаботникиОрганизации.(МесяцРегистрации) КАК РаботникиОрганизации";*/
		}

		public void ОпределитьНеобходимостьПроверкиПоПериодуРегистрации(/*ПараметрыПроверкиДокумента, МетаданныеДокумента*/)
		{
			if(true/*МетаданныеДокумента.Реквизиты.Найти("ПериодРегистрации") <> Неопределено*/)
			{
				//ПараметрыПроверкиДокумента.Вставить("ИмяПоляПериодаРегистрации", "ПериодРегистрации");
			}
			//ИмяПоляПериодРегистрацииДокуметнов = Новый Соответствие;
			//ИмяПоляПериодРегистрацииДокуметнов.Вставить(Метаданные.Документы.ВводПроцентаДеятельностиЕНВД,								"Период");
			//ИмяПоляПериодРегистрацииДокуметнов.Вставить(Метаданные.Документы.ВводРаспределенияОсновногоЗаработкаРаботниковОрганизации,	"Период");
			//АльтернативноеИмяРеквизита = ИмяПоляПериодРегистрацииДокуметнов[МетаданныеДокумента];
			if(true/*АльтернативноеИмяРеквизита <> Неопределено*/)
			{
				//ПараметрыПроверкиДокумента.Вставить("ИмяПоляПериодаРегистрации", АльтернативноеИмяРеквизита);
			}
		}
		// Функция возвращает структуру с параметрами проверки документа по умолчанию
		//

		public object ПолучитьПараметрыПроверкиДокумента(/*ДокументОбъект*/)
		{
			//ПараметрыПроверкиДокумента = Новый Структура;
			//МетаданныеДокумента = ДокументОбъект.Метаданные();
			//ПараметрыПроверкиДокумента.Вставить("МетаданныеДокумента", МетаданныеДокумента);
			/*// если  в документе есть реквизит организация, дата запрета оперделяется с учетом организации
*/
			//ПараметрыПроверкиДокумента.Вставить("ЕстьОрганизация", 			(МетаданныеДокумента.Реквизиты.Найти("Организация") <> Неопределено));
			//ПараметрыПроверкиДокумента.Вставить("ЕстьУправленческийУчет",	(МетаданныеДокумента.Реквизиты.Найти("ОтражатьВУправленческомУчете") <> Неопределено));
			//ПараметрыПроверкиДокумента.Вставить("ЕстьБухгалтерскийУчет", 	(МетаданныеДокумента.Реквизиты.Найти("ОтражатьВБухгалтерскомУчете") <> Неопределено));
			//ПараметрыПроверкиДокумента.Вставить("ЕстьНалоговыйУчет", 		(МетаданныеДокумента.Реквизиты.Найти("ОтражатьВНалоговомУчете") <> Неопределено));
			//ОпределитьНеобходимостьПроверкиПоПериодуРегистрации(ПараметрыПроверкиДокумента, МетаданныеДокумента);
			/*// Если для документа проведение запрещено, проверка на дату запрета редактирования
*/
			/*//проверяется без учета проведенности
*/
			//ПараметрыПроверкиДокумента.Вставить("ПроверятьПроведениеДокумента", (МетаданныеДокумента.Проведение = Метаданные.СвойстваОбъектов.Проведение.Разрешить));
			if(true/*ЗаполнитьПараметрыПроверкиПоВидуДокумента(ДокументОбъект, ПараметрыПроверкиДокумента)*/)
			{
			}
			//ПроверятьУправленческуюДатуЗапрета      = (НЕ ПараметрыПроверкиДокумента.ЕстьОрганизация) или (ПараметрыПроверкиДокумента.ЕстьУправленческийУчет и ДокументОбъект["ОтражатьВУправленческомУчете"]);
			/*УстановленФлагБУилиНУ = (ПараметрыПроверкиДокумента.ЕстьБухгалтерскийУчет И ДокументОбъект["ОтражатьВБухгалтерскомУчете"])
						ИЛИ (ПараметрыПроверкиДокумента.ЕстьНалоговыйУчет И ДокументОбъект["ОтражатьВНалоговомУчете"]);*/
			//ОтсутствуютРеквизитыБУиНУ = НЕ (ПараметрыПроверкиДокумента.ЕстьБухгалтерскийУчет ИЛИ ПараметрыПроверкиДокумента.ЕстьНалоговыйУчет);
			//ПроверятьРегламентированнуюДатуЗапрета  = ПараметрыПроверкиДокумента.ЕстьОрганизация И (ОтсутствуютРеквизитыБУиНУ ИЛИ УстановленФлагБУилиНУ);
			//ПараметрыПроверкиДокумента.Вставить("ПроверятьУправленческуюДатуЗапрета", 		ПроверятьУправленческуюДатуЗапрета);
			//ПараметрыПроверкиДокумента.Вставить("ПроверятьРегламентированнуюДатуЗапрета", 	ПроверятьРегламентированнуюДатуЗапрета);
			return null;
		}
		// ПолучитьПараметрыПроверкиДокумента()
		//Функция возвращает структуру параметров проверки документа для нетиповых случаев
		//

		public object ЗаполнитьПараметрыПроверкиПоВидуДокумента(/*ДокументОбъект, ПараметрыПроверкиДокумента*/)
		{
			/*//Если ПараметрыПроверкиДокумента.МетаданныеДокумента.Имя = "<ИмяДокумента>" Тогда		
*/
			/*//	ЗаполнитьПараметрыПроверкиДокумента<ИмяДокумента>(ДокументОбъект, ПараметрыПроверкиДокумента);
*/
			/*//Иначе
*/
			/*//КонецЕсли;	
*/
			return null;
		}
		// ЗаполнитьПараметрыПроверкиПоВидуДокумента()

		public object ДокументВЗакрытомПериоде(/*ДокументОбъект*/)
		{
			//Результат = Ложь;
			//СоответствиеГраницЗапрета = ПараметрыСеанса.ГраницыЗапретаИзмененияДанных.Получить();
			/*// Для пользователя с полными правами проверок выполнять не нужно
*/
			if(true/*СоответствиеГраницЗапрета = Неопределено*/)
			{
			}
			//ПараметрыПроверкиДокумента = ПолучитьПараметрыПроверкиДокумента(ДокументОбъект);
			//ПроверитьВерсиюДокумента(ДокументОбъект, ПараметрыПроверкиДокумента, СоответствиеГраницЗапрета, Результат);
			return null;
		}
		// ДокументВЗакрытомПериоде()

		public object ПолучитьИмяПоляПериодаДляРегистра(/*ВидРегистра, РегистрМетаданные*/)
		{
			//ПолеПериод = "Период";
			if(true/*ВидРегистра = "РегистрРасчета"*/)
			{
				//ПолеПериод = "ПериодРегистрации";
			}
			return null;
		}
		// Процедура выполняет проверку возможности записи регистров сведений, регистров накопления
		// регистров бухгалтерии и регистров расчета
		// с учетом даты запрета изменения данных (даты запрета редактирования)
		//

		public void ПроверкаПериодаЗаписейРегистров(/*НаборЗаписей, Отказ, ВидРегистра = "РегистрНакопления"*/)
		{
			//СоответствиеГраницЗапрета = ПараметрыСеанса.ГраницыЗапретаИзмененияДанных.Получить();
			/*// Для пользователя с полными правами проверок выполнять не нужно
*/
			if(true/*СоответствиеГраницЗапрета = Неопределено*/)
			{
			}
			//МетаданныеНабора = НаборЗаписей.Метаданные();
			/*// Проверку существующих записей выполняем только для регистров, подчиненных регистратору.
*/
			/*// Проверка необходима, так как недопустимо удаление записей прошлого периода (в результате перезаписи набора).
*/
			/*ПроверятьСуществующиеЗаписиПоРегистратору =
		НРег(ВидРегистра) <> НРег("РегистрСведений")
		ИЛИ МетаданныеНабора.РежимЗаписи = Метаданные.СвойстваОбъектов.РежимЗаписиРегистра.ПодчинениеРегистратору;*/
			if(true/*ПроверятьСуществующиеЗаписиПоРегистратору*/)
			{
				//Регистратор = НаборЗаписей.Отбор.Регистратор.Значение;
				/*// Для регламентного документа расчета себестоимости проверять период записей не нужно
*/
				if(true/*ТипЗнч(Регистратор) = Тип("ДокументСсылка.РасчетСебестоимостиВыпуска")*/)
				{
				}
			}
			//ЕстьОрганизация = (МетаданныеНабора.Измерения.Найти("Организация") <> Неопределено);
			/*// В регистре расчета проверяется системное поле ПериодДействия, в остальных регистрах проверяется поле Период
*/
			//ПолеПериод 		= ПолучитьИмяПоляПериодаДляРегистра(ВидРегистра, МетаданныеНабора);
			//СтруктураПараметров = Новый Структура;
			//СтруктураПараметров.Вставить("СоответствиеГраницЗапрета", 	СоответствиеГраницЗапрета);
			//СтруктураПараметров.Вставить("МетаданныеНабора", 			МетаданныеНабора);
			//СтруктураПараметров.Вставить("ЕстьОрганизация", 			ЕстьОрганизация);
			//СтруктураПараметров.Вставить("ПолеПериод", 					ПолеПериод);
			if(true/*ПроверятьСуществующиеЗаписиПоРегистратору*/)
			{
				//ПроверкаСуществующихЗаписейРегистра(НаборЗаписей, СтруктураПараметров, Отказ);
			}
			/*// Проверка периода текущих записей набора	
*/
			if(true/*НЕ Отказ И НаборЗаписей.Количество() > 0*/)
			{
				//ГраницаПериодаОсновная 	= СоответствиеГраницЗапрета[Справочники.Организации.ПустаяСсылка()];
				//ГраницаПериодаОбщая 	= СоответствиеГраницЗапрета["ОбщаяДатаЗапретаРедактирования"];
				if(true/*ЕстьОрганизация*/)
				{
				}
			}
		}

		public void ПроверкаСуществующихЗаписейРегистра(/*НаборЗаписей, СтруктураПараметров, Отказ*/)
		{
			//ИмяРегистра = СтруктураПараметров.МетаданныеНабора.ПолноеИмя();
			//СтруктураПараметров.Свойство("ПолеПериод", 	ИмяПоляПериода);
			//Запрос = Новый Запрос;
			//ВложенныйЗапрос = "";
			if(true/*СтруктураПараметров.ЕстьОрганизация*/)
			{
				//Индекс = 1;
				//ИмяПоляОрганизации = "Организация";
			}
			/*Запрос.Текст = "
	|ВЫБРАТЬ ПЕРВЫЕ 1 1
	|ИЗ
	|(
	|ВЫБРАТЬ " + ИмяПоляОрганизации + " КАК Организация, МИНИМУМ(" + ИмяПоляПериода + ") КАК Период  ИЗ " + ИмяРегистра + " КАК Набор
	|ГДЕ Регистратор = &Регистратор
	|СГРУППИРОВАТЬ ПО " + ИмяПоляОрганизации + "
	|) КАК НаборЗаписей
	|ЛЕВОЕ СОЕДИНЕНИЕ
	|(" + ВложенныйЗапрос + "		
	|) КАК ДатыЗапрета
	|ПО НаборЗаписей.Организация = ДатыЗапрета.Организация
	|ГДЕ НаборЗаписей.Период <= ДатыЗапрета.ДатаЗапрета ИЛИ ДатыЗапрета.ДатаЗапрета ЕСТЬ NULL";*/
			//Запрос.УстановитьПараметр("Регистратор", НаборЗаписей.Отбор.Регистратор.Значение);
			if(true/*НЕ Запрос.Выполнить().Пустой()*/)
			{
				//Отказ = Истина;
			}
		}

		public void ПроверкаСуществующихЗаписейРегистраСведений(/*НаборЗаписей, СтруктураПараметров, Отказ*/)
		{
			//ИмяРегистра = СтруктураПараметров.МетаданныеНабора.ПолноеИмя();
			/*// Формируем текст условия блока ГДЕ основного запроса,
*/
			/*// в соответствии с установленным отбором для набора записей
*/
			//Запрос = Новый Запрос;
			//СписокПолейУсловияОтбораТекст = "";
			//Итерация = 0;
			if(true/*Итерация = 1*/)
			{
				//СписокПолейУсловияОтбораТекст = " ГДЕ " + СписокПолейУсловияОтбораТекст;
			}
			//ВложенныйЗапрос = "";
			if(true/*СтруктураПараметров.ЕстьОрганизация*/)
			{
				//индекс = 1;
				//ИмяПоляОрганизации = "Организация";
			}
			/*Запрос.Текст = "
    |ВЫБРАТЬ ПЕРВЫЕ 1 1
    |ИЗ
    |(
    |ВЫБРАТЬ " + ИмяПоляОрганизации + " КАК Организация, МИНИМУМ(Период) КАК Период  ИЗ " + ИмяРегистра + " КАК Набор
    | "+ СписокПолейУсловияОтбораТекст + "
    |СГРУППИРОВАТЬ ПО " + ИмяПоляОрганизации + "
    |) КАК НаборЗаписей
    |ЛЕВОЕ СОЕДИНЕНИЕ
    |(" + ВложенныйЗапрос + "		
    |) КАК ДатыЗапрета
    |ПО НаборЗаписей.Организация = ДатыЗапрета.Организация
    |ГДЕ НаборЗаписей.Период <= ДатыЗапрета.ДатаЗапрета ИЛИ ДатыЗапрета.ДатаЗапрета ЕСТЬ NULL";*/
			if(true/*НЕ Запрос.Выполнить().Пустой()*/)
			{
				//Отказ = Истина;
			}
		}
		/////////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ  - ОБРАБОТЧИКИ ПОДПИСОК НА СОБЫТИЯ МЕХАНИЗМА ДАТЫ ЗАПРЕТА РЕДАКТИРОВАНИЯ
		// Проверка возможности записи данных документа с учетом даты запрета изменения данных (даты запрета редактирования)
		//

		public void ПередЗаписьюДокументаПроверкаДоступностиПериода(/*Источник, Отказ, РежимЗаписи, РежимПроведения*/)
		{
			if(true/*Отказ ИЛИ Источник.ОбменДанными.Загрузка*/)
			{
			}
			//ПроверкаПериодаДокумента(Источник, Отказ, РежимЗаписи);
			if(true/*Отказ*/)
			{
				//Сообщить("Редактирование данных этого периода запрещено. Изменения не могут быть записаны...", СтатусСообщения.Важное);
			}
		}
		// ПередЗаписьюДокументовПроверкаДоступностиПериода
		// Проверка возможности изменения записей регистров (дата запрета изменения данных)
		//

		public void ПередЗаписьюРегистраНакопленийПроверкаДоступностиПериода(/*Источник, Отказ, Замещение*/)
		{
			if(true/*Отказ ИЛИ Источник.ОбменДанными.Загрузка*/)
			{
			}
			//ПроверкаПериодаЗаписейРегистров(Источник, Отказ, "РегистрНакопления");
			if(true/*Отказ*/)
			{
				//Сообщить("Редактирование данных этого периода запрещено. Изменения не могут быть записаны...", СтатусСообщения.Важное);
			}
		}
		// ПередЗаписьюРегистраНакопленийПроверкаДоступностиПериода

		public void ПередЗаписьюРегистраБухгалтерииПроверкаДоступностиПериода(/*Источник, Отказ, Замещение*/)
		{
			if(true/*Отказ ИЛИ Источник.ОбменДанными.Загрузка*/)
			{
			}
			//ПроверкаПериодаЗаписейРегистров(Источник, Отказ, "РегистрБухгалтерии");
			if(true/*Отказ*/)
			{
				//Сообщить("Редактирование данных этого периода запрещено. Изменения не могут быть записаны...", СтатусСообщения.Важное);
			}
		}
		// ПередЗаписьюРегистраНакопленийПроверкаДоступностиПериода
		// Проверка возможности изменения записей регистров (дата запрета изменения данных)
		//

		public void ПередЗаписьюРегистраРасчетаПроверкаДоступностиПериода(/*Источник, Отказ, Замещение, ТолькоЗапись*/)
		{
			if(true/*Отказ ИЛИ Источник.ОбменДанными.Загрузка*/)
			{
			}
			//ПроверкаПериодаЗаписейРегистров(Источник, Отказ, "РегистрРасчета");
			if(true/*Отказ*/)
			{
				//Сообщить("Редактирование данных этого периода запрещено. Изменения не могут быть записаны...", СтатусСообщения.Важное);
			}
		}
		// ПередЗаписьюРегистраРасчетаПроверкаДоступностиПериода
		// Проверка возможности изменения записей регистров (дата запрета изменения данных)
		//

		public void ПередЗаписьюРегистраСведенийПроверкаДоступностиПериода(/*Источник, Отказ, Замещение*/)
		{
			if(true/*Отказ ИЛИ Источник.ОбменДанными.Загрузка*/)
			{
			}
			//ПроверкаПериодаЗаписейРегистров(Источник, Отказ, "РегистрСведений");
			if(true/*Отказ*/)
			{
				//Сообщить("Редактирование данных этого периода запрещено. Изменения не могут быть записаны...", СтатусСообщения.Важное);
			}
		}
		// ПередЗаписьюРегистраСведенийПроверкаДоступностиПериода

		public void ОпределитьДоступностьВозможностьИзмененияДокументаПоДатеЗапрета(/*ДокументОбъект, ФормаДокумента*/)
		{
			if(true/*НЕ ФормаДокумента.ТолькоПросмотр*/)
			{
				//ФормаДокумента.ТолькоПросмотр = НастройкаПравДоступа.ДокументВЗакрытомПериоде(ДокументОбъект);
			}
		}
		// ОпределитьДоступностьВозможностьИзмененияДокументаПоДатеЗапрета

		public object ПолучитьОбъектыДоступаДокумента(/*ИмяДокумента*/)
		{
			//Результат = Новый Соответствие;
			if(true/*ИмяДокумента = "АктОбОказанииПроизводственныхУслуг"*/)
			{
				//Результат.Вставить("Проект", Перечисления.ВидыОбъектовДоступа.Проекты);
			}
			return null;
		}
		// Записывает объекты доступа для документа
		//

		public void ВыполнитьРегистрациюОбъектовДоступаДокумента(/*Источник*/)
		{
			//ИсточникИмя = Источник.Метаданные().Имя;
			//ОбъектыДоступаДокумента = ПолучитьОбъектыДоступаДокумента(ИсточникИмя);
			if(true/*ОбъектыДоступаДокумента.Количество() = 0*/)
			{
				//ВызватьИсключение "Не определено правило регистрации объектов доступа для документа: " + ИсточникИмя;
			}
			//ОбъектыДоступа = Новый ТаблицаЗначений;
			//ОбъектыДоступа.Колонки.Добавить("ВидОбъектаДоступа");
			//ОбъектыДоступа.Колонки.Добавить("ОбъектДоступа");
			if(true/*Источник.ДополнительныеСвойства.Свойство("ПараметрыЗаписиОбъектовДоступа")*/)
			{
				//Замещать = Источник.ДополнительныеСвойства.ПараметрыЗаписиОбъектовДоступа.Замещать;
			}
			//ПолныеПрава.РегистрацияОбъектовДоступаДокумента(Источник.Ссылка, ОбъектыДоступа, Замещать);
		}
		// Обработчик подписки на событие ПриЗаписиДокументаРегистрацияОбъектовДоступа
		//

		public void ПриЗаписиДокументаРегистрацияОбъектовПравДоступа(/*Источник, Отказ*/)
		{
			if(true/*Источник.ОбменДанными.Загрузка*/)
			{
			}
			//ВыполнитьРегистрациюОбъектовДоступаДокумента(Источник);
		}

		public void ПриЗаписиДокументаРегистрацияОбъектовДоступаПередЗаписью(/*Источник, Отказ, РежимЗаписи, РежимПроведения*/)
		{
			//ДополнительныеСвойства = Источник.ДополнительныеСвойства;
			//ДополнительныеСвойства.Вставить("ПараметрыЗаписиОбъектовДоступа", Новый Структура("Замещать"));
			//ДополнительныеСвойства.ПараметрыЗаписиОбъектовДоступа.Замещать = НЕ Источник.ЭтоНовый();
		}
		// Выполняет регистрацию объектов доступа по списку документов
		// Процедура может использоваться при обновлении ИБ
		//
		// Параметры
		//  ТипыДокументов			- массив - содержит названия документов, для которых нужно выпонить регистрацию объектов доступа
		//
		//  ЗаменятьСуществующие	- булево - признак замены существующих объектов доступа
		//

		public void ВыполнитьРегистрациюОбъектовДоступа(/*ТипыДокументов, ЗаменятьСуществующие = Истина*/)
		{
			//ТекстЗапроса = "";
			//ПервыйРаз = Истина;
			/*//Первый проход цикла
*/
			//Запрос = Новый Запрос;
			//Запрос.Текст = ТекстЗапроса;
			//Результат = Запрос.Выполнить();
			//Выборка = Результат.Выбрать();
			while(true/*Выборка.Следующий()*/)
			{
				//ДокументОбъект = Выборка.Ссылка.ПолучитьОбъект();
				//ВыполнитьРегистрациюОбъектовДоступаДокумента(ДокументОбъект);
			}
			//;;
		}
		/////////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ  - МЕХАНИЗМА КОНТРОЛЯ ОТРАЖЕНИЯ В РЕГЛ УЧЕТЕ
		// Функция проверяет наличие права пользователя отразить в регл. учете
		// Если пользователю разрешено отражать в регл. учете, то функция возвращает ИСТИНА
		// Если пользователю запрещено отражать в регл. учете, то
		//  - если в документе установлен признак отражения в регл. учете, то функция возвращает ЛОЖЬ
		//  - если в документе не установлен признак отражения в регл. учете, то необходимо проверить
		//    версию документа до изменений
		//

		public object ПроверитьВозможностьОтраженияВРеглУчете(/*ДокументОбъект, РежимЗаписи*/)
		{
			/*// Если пользователю разрешено отражать в регл учете, то выполнение процедуры завершается
*/
			//ЗаписьРазрешена = УправлениеДопПравамиПользователей.РазрешеноОтражениеВРеглУчете();
			if(true/*ЗаписьРазрешена*/)
			{
			}
			/*// Пользователю запрешено отражать в регл. учете
*/
			//МетаданныеДокумента = ДокументОбъект.Метаданные();
			//ЕстьРеквизитБУ      = (МетаданныеДокумента.Реквизиты.Найти("ОтражатьВБухгалтерскомУчете") <> Неопределено);
			//ЕстьРеквизитНУ      = (МетаданныеДокумента.Реквизиты.Найти("ОтражатьВНалоговомУчете") <> Неопределено);
			//РазрешеноПроведение = (МетаданныеДокумента.Проведение = Метаданные.СвойстваОбъектов.Проведение.Разрешить);
			/*// Проверим текущую версию документа	
*/
			if(true/*НЕ ЕстьРеквизитБУ 
		ИЛИ ЕстьРеквизитБУ И ДокументОбъект.ОтражатьВБухгалтерскомУчете
		ИЛИ ЕстьРеквизитНУ И ДокументОбъект.ОтражатьВНалоговомУчете*/)
			{
				if(true/*РежимЗаписи = РежимЗаписиДокумента.ОтменаПроведения*/)
				{
					/*// Если отмена проведения, то нужно проверить версию документа до изменений
*/
					//ЗаписьРазрешена = Истина;
				}
			}
			/*// Проверим версию документа до изменений
*/
			if(true/*ЗаписьРазрешена И НЕ ДокументОбъект.ЭтоНовый()*/)
			{
				//Запрос = Новый Запрос;
				/*ТекстЗапроса = "ВЫБРАТЬ
			|	" + ?(ЕстьРеквизитБУ, "Док.ОтражатьВБухгалтерскомУчете ", "ИСТИНА") + " КАК ОтражатьВБухгалтерскомУчете,
			|	" + ?(ЕстьРеквизитНУ, "Док.ОтражатьВНалоговомУчете", "ЛОЖЬ") + " КАК ОтражатьВНалоговомУчете,
			|	" + ?(РазрешеноПроведение, "Док.Проведен", "ИСТИНА") + " КАК Проведен
			|ИЗ
			|	Документ." + МетаданныеДокумента.Имя + " КАК Док
			|ГДЕ 
			|	Док.Ссылка = &Ссылка";*/
				//Запрос.Текст = ТекстЗапроса;
				//Запрос.УстановитьПараметр("Ссылка", ДокументОбъект.Ссылка);
				//Результат = Запрос.Выполнить();
				//Выборка = Результат.Выбрать();
				//Выборка.Следующий();
				if(true/*НЕ ЕстьРеквизитБУ 
			ИЛИ ЕстьРеквизитБУ И Выборка.ОтражатьВБухгалтерскомУчете
			ИЛИ ЕстьРеквизитНУ И Выборка.ОтражатьВНалоговомУчете*/)
				{
					if(true/*НЕ Выборка.Проведен И РазрешеноПроведение*/)
					{
						/*// Можно изменить только непроведенный документ
*/
						//ЗаписьРазрешена = Истина;
					}
				}
			}
			if(true/*НЕ ЗаписьРазрешена*/)
			{
				//СтруктураПараметровПроведения = ОтложенноеПроведениеДокументов.ПолучитьПараметрыПроведенияДокумента(ДокументОбъект);
				/*// Документ можно отразить в регл учете,
*/
				/*// если документ проводится отложенно 
*/
				/*// и предыдущая версия документа не проведена полностью
*/
				/*ЗаписьРазрешена = СтруктураПараметровПроведения.ДокументИспользуетсяВОтложенномПроведении
							И СтруктураПараметровПроведения.ВыполняетсяОтложенноеПроведение
							И (ДокументОбъект.ЭтоНовый()
								ИЛИ НЕ ОтложенноеПроведениеДокументов.ПроверитьДокументПроведенПолностью(ДокументОбъект.Ссылка));*/
			}
			return null;
		}
		//ПроверитьВозможностьОтраженияВРеглУчете

		public void ПередЗаписьюДокументаОтражениеВРеглУчетеПередЗаписью(/*Источник, Отказ, РежимЗаписи, РежимПроведения*/)
		{
			//ЗапретитьЗапись = НЕ ПроверитьВозможностьОтраженияВРеглУчете(Источник, РежимЗаписи);
			//Отказ = Отказ ИЛИ ЗапретитьЗапись;
			if(true/*ЗапретитьЗапись*/)
			{
				//ТекстСообщения = "Недостаточно прав для отражения в регламентированном учете. Изменения не могут быть записаны...";
				//Заголовок = "Запись документа: " + Строка(Источник);
				//ОбщегоНазначения.СообщитьОбОшибке(ТекстСообщения, , Заголовок, СтатусСообщения.Важное, Источник.Ссылка);
			}
		}
		/////////////////////////////////////////////////////////////////////////////////////
		// ПРОЦЕДУРЫ - АДМИНИСТРИРОВАНИЯ ПОЛЬЗОВАТЕЛЕЙ

		public void ОткрытьПараметрыДоступаНаУровнеЗаписей(/**/)
		{
			//Обработки.НастройкиПрограммы.ПолучитьФорму("ПараметрыДоступаНаУровнеЗаписей").Открыть();
		}
		//
		// Функция возвращает массив используемых видов объектов доступа
		//	для конфигурации в целом или для группы пользователя
		//

		public object ПолучитьИспользуемыеВидыОбъектовДоступа(/*ГруппаПользователя = Неопределено*/)
		{
			//Запрос = Новый Запрос;
			if(true/*ГруппаПользователя = Неопределено*/)
			{
				/*ТекстЗапроса = "ВЫБРАТЬ
		               |	ИспользуемыеВидыОбъектовДоступа.ВидОбъектаДоступа КАК ВидОбъектаДоступа
		               |ИЗ
		               |	РегистрСведений.ИспользуемыеВидыОбъектовДоступа КАК ИспользуемыеВидыОбъектовДоступа";*/
			}
			//Запрос.Текст = ТекстЗапроса;
			//Результат = Запрос.Выполнить().Выгрузить().ВыгрузитьКолонку("ВидОбъектаДоступа");
			return null;
		}
		// ПолучитьИспользуемыеВидыОбъектовДоступа
	}
}
